home *** CD-ROM | disk | FTP | other *** search
/ Oh!X 2000 Spring / Oh!X 2000 Spring Special CD-ROM (Japan) (Part 1).7z / Oh!X 2000 Spring Special CD-ROM (Japan) (Part 1).bin / F2JW / trans / print.cpp < prev    next >
C/C++ Source or Header  |  1999-08-22  |  47KB  |  1,555 lines
  1. #include "stdafx.h"
  2. #include    <string.h>
  3. #include    <ctype.h>
  4.  
  5. // #include    <iostream.h>
  6.  
  7. #include    "f2j.h"
  8. #include    "myprot.h"
  9.  
  10. extern    TOKEN    *currentTree;
  11. extern    JP_UNIT_INFO    jpUnitInforTable[];
  12.  
  13.  
  14. extern const char *jpVerbTailTable_Keiyoshi[JP_CHANGE_LAST];
  15. extern const char *jpVerbTailTable_KeiyoDoshi[JP_CHANGE_LAST];
  16. extern const char *jpVerbTailTable_Rentaishi[JP_CHANGE_LAST];
  17. extern const char *jpVerbTailTable_Adverb[JP_CHANGE_LAST];
  18. extern const char *jpVerbTailTable_Devoir[JP_CHANGE_LAST];
  19. extern const char *jpVerbTailTable_Falloir[JP_CHANGE_LAST];
  20. extern const char *jpVerbTailTable_Pouvoir[JP_CHANGE_LAST];
  21.  
  22. extern const char *jpVerbTailTable_Godan[15][JP_CHANGE_LAST];
  23.  
  24. extern const char *jpVerbTailTable_Upper1[15];
  25. extern const char *jpVerbTailTable_Lower1[15];
  26.  
  27. extern const char *jpVerbTailTable_Noroot[JP_CHANGE_LAST];
  28. extern const char *jpVerbTailTable_Other[JP_CHANGE_LAST];
  29. extern const char *jpVerbTailTable_Other2[JP_CHANGE_LAST];
  30. extern const char *jpVerbTailTable_Kahen[JP_CHANGE_LAST];
  31. extern const char *jpVerbTailTable_Sahen[JP_CHANGE_LAST];
  32. extern const char *jpVerbTailTable_Sahen2[JP_CHANGE_LAST];
  33. extern const char *jpVerbTailTable_Aru[JP_CHANGE_LAST];
  34. extern const char *jpVerbTailTable_Masu[JP_CHANGE_LAST];
  35. extern const char *jpVerbTailTable_Rasii[JP_CHANGE_LAST];
  36. extern const char *jpVerbTailTable_Ta[JP_CHANGE_LAST];
  37. extern const char *jpVerbTailTable_Da[JP_CHANGE_LAST];
  38. extern const char *jpVerbTailTable_Desu[JP_CHANGE_LAST];
  39.  
  40. // 動詞にかかる言葉の優先順位
  41. FR_PATTERN    verbSortTable[] = {
  42.     FR_PATTERN( CMP_TOKEN(  FR_PART_ADJECTIVE_EXCLAMINATION),    9 ),
  43.     FR_PATTERN( CMP_TOKEN(  FR_PART_ADVERB_EXCLAMINATION),        9 ),
  44.     FR_PATTERN( CMP_TOKEN(  FR_PART_SENTENCE_ALL),                8 ),
  45.     FR_PATTERN( CMP_TOKEN(  FR_PART_PREPOSIT_QUAND),            7 ),
  46.     FR_PATTERN( CMP_TOKEN(  FR_PART_INDEPENDENCE_ALL),            10 ),
  47.     FR_PATTERN( CMP_TOKEN(  FR_PART_PREPOSIT_EN_ENT),            5 ),
  48.     FR_PATTERN( CMP_TOKEN(  FR_PART_RELATIVE_ALL),                4 ),
  49.     FR_PATTERN( CMP_TOKEN(  FR_PART_ADJECTIVE_ALL),                3 ),
  50.     FR_PATTERN( CMP_TOKEN(  FR_PART_ALL),                        2 ),
  51.     FR_PATTERN( CMP_TOKEN(  FR_PART_NONE )),
  52. };
  53.  
  54.  
  55. //
  56. // 助詞をメタキャラから表示
  57. //
  58. BOOL
  59. PrintOutJpPreposition(char *s, JP_EMPHASIS jpEmphasis, PRT_CONTROL prtControl)
  60. {
  61.     char    t[100];
  62.     t[0] = '\0';
  63.  
  64.     if(StringCmp(s, "A")) {
  65.         if(jpEmphasis & JP_EMPHASIS_HOU)        strcat(t, "の方");
  66.         if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "のことしか");
  67.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "のことだけ");
  68.         else if(jpEmphasis & JP_EMPHASIS_DEMO)    strcat(t, "のことでも");
  69.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "のことも");
  70.         else                                    strcat(t, "のことが");
  71.     } else if(StringCmp(s, "B")) {
  72.         if(jpEmphasis & JP_EMPHASIS_HOU)        strcat(t, "の方");
  73.         if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "のことしか");
  74.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "のことだけ");
  75.         else if(jpEmphasis & JP_EMPHASIS_DEMO)    strcat(t, "のことでも");
  76.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "のことも");
  77.         else                                    strcat(t, "のことを");
  78.     } else if(StringCmp(s, "C")) {
  79.         if(jpEmphasis & JP_EMPHASIS_GA)            strcat(t, "に");
  80.         else if(jpEmphasis & JP_EMPHASIS_DEMO)    strcat(t, "にも");
  81.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "にも");
  82.         else if(jpEmphasis & JP_EMPHASIS_ONLY)    strcat(t, "しか");
  83.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  84.         else                                    strcat(t, "には");
  85.     } else if(StringCmp(s, "D")) {
  86.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  87.         strcat(t, "で");
  88.     } else if(StringCmp(s, "E")) {
  89.         if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "へしか");
  90.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "へも");
  91.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "へだけ");
  92.         else                                    strcat(t, "へ");
  93.     } else if(StringCmp(s, "F")) {
  94.         if(jpEmphasis & JP_EMPHASIS_HOU)        strcat(t, "事の方");
  95.         else if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "事しか");
  96.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "事だけ");
  97.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "事も");
  98.         else                                    strcat(t, "事が");
  99.     } else if(StringCmp(s, "G")) {
  100.         if(jpEmphasis & JP_EMPHASIS_HOU)        strcat(t, "の方");
  101.         if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "しか");
  102.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけが");
  103.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "も");
  104.         else                                    strcat(t, "が");
  105.     } else if(StringCmp(s, "H")) {
  106.         // La voiture, c'est belle.
  107.         if(jpEmphasis & JP_EMPHASIS_CE)            strcat(t, "こそ");
  108.         if(jpEmphasis & JP_EMPHASIS_MO)            strcat(t, "も");
  109.         else if(jpEmphasis & JP_EMPHASIS_GA)    strcat(t, "が");
  110. //        else if(jpEmphasis & JP_EMPHASIS_NI)    strcat(t, "に");
  111.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけが");
  112.         else                                    strcat(t, "は");
  113.     } else if(StringCmp(s, "I")) {
  114.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  115.                                                 strcat(t, "に");
  116.         if(jpEmphasis & JP_EMPHASIS_MO)            strcat(t, "も");
  117.     } else if(StringCmp(s, "J")) {
  118.                                                 strcat(t, "事");
  119.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  120.                                                 strcat(t, "に");
  121.         if(jpEmphasis & JP_EMPHASIS_MO)            strcat(t, "も");
  122.     } else if(StringCmp(s, "K")) {
  123.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  124.         strcat(t, "から");
  125.     } else if(StringCmp(s, "L")) {
  126.         if((jpEmphasis & JP_EMPHASIS_ONLY)
  127.         || (jpEmphasis & JP_EMPHASIS_SEULEMENT))strcat(t, "へだけの");
  128.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "へも");
  129.         else                                    strcat(t, "への");
  130.     } else if(StringCmp(s, "N")) {
  131.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  132.         strcat(t, "の");
  133.     } else if(StringCmp(s, "S")) {
  134.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  135.         strcat(t, "として");
  136.     } else if(StringCmp(s, "T")) {
  137.         if(jpEmphasis & JP_EMPHASIS_HOU)        strcat(t, "の方");
  138.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  139.         strcat(t, "と");
  140.     } else if(StringCmp(s, "U")) {
  141.                                                 strcat(t, "事");
  142.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  143.         if(jpEmphasis & JP_EMPHASIS_MO)            strcat(t, "も");
  144.     } else if(StringCmp(s, "V")) {
  145.                                                 strcat(t, "事");
  146.         if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  147.         if(jpEmphasis & JP_EMPHASIS_MO)            strcat(t, "も");
  148.         else                                    strcat(t, "を");
  149.     } else if(StringCmp(s, "W")) {
  150. //        if(jpEmphasis & JP_EMPHASIS_HOU)        strcat(t, "の方");
  151.         if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "しか");
  152.         else if(jpEmphasis & JP_EMPHASIS_SEULEMENT)    strcat(t, "だけ");
  153.         else if(jpEmphasis & JP_EMPHASIS_DEMO)    strcat(t, "でも");
  154.         else if(jpEmphasis & JP_EMPHASIS_MO)    strcat(t, "も");
  155.         else                                    strcat(t, "を");
  156.     } else if(StringCmp(s, "Y")) {
  157.         strcat(t, "よりも");
  158.     } else if(StringCmp(s, "<にとって>")) {
  159.         strcat(t, "にとって");
  160.     } else if(StringCmp(s, "<の言うことを>")) {
  161.         if(jpEmphasis & JP_EMPHASIS_MO)            strcat(t, "の言うことも");
  162.         else                                    strcat(t, "の言うことを");
  163.     } else if(StringCmp(s, "<のために>")) {
  164.         strcat(t, "のために");
  165.         if(jpEmphasis & JP_EMPHASIS_ONLY)        strcat(t, "しか");
  166.     } else {
  167.         // 該当なし
  168.         return(FALSE);
  169.     }
  170.  
  171.     if(prtControl != PRT_CONTROL_DISABLE)    // PRT_CONTROL_REPLACEでは表示する
  172.         MyPrintf(t);
  173.     return(TRUE);
  174. }
  175.  
  176. //
  177. // jpChangeをメタキャラから設定
  178. //
  179. BOOL
  180. SetJpChange(char c, TOKEN *p, JP_CHANGE *jpChange, PRT_CONTROL *prtControl, BOOL *extendFlag)
  181. {
  182.     switch(c) {
  183.     case 'a':
  184.         *jpChange = JP_CHANGE_ADJECTIVE;
  185.         break;
  186.     case 'c':
  187.         *jpChange = JP_CHANGE_ADVERB;
  188.         break;
  189.     case 'e':
  190.         *jpChange = JP_CHANGE_ABLE;
  191.         break;
  192.     case 'f':
  193.         *jpChange = JP_CHANGE_FORCE;
  194.         break;
  195.     case 'g':
  196.         *jpChange = JP_CHANGE_PLEASE;
  197.         break;
  198.     case 'h':
  199.         *jpChange = JP_CHANGE_TAI;
  200.         break;
  201.     case 'i':
  202.         *jpChange = JP_CHANGE_IF;
  203.         break;
  204.     case 'l':
  205.         *jpChange = JP_CHANGE_LETS;
  206.         break;
  207.     case 'n':
  208.         *jpChange = JP_CHANGE_NEGATIVE;
  209.         break;
  210.     case 'o':
  211.         *jpChange = JP_CHANGE_ORDER;
  212.         break;
  213.     case 'p':
  214.         *jpChange = JP_CHANGE_PASSE;
  215.         break;
  216.     case 'r':
  217.         *jpChange = JP_CHANGE_RESPECT;
  218.         break;
  219.     case 's':
  220.         *jpChange = JP_CHANGE_STOP;
  221.         break;
  222.     case 't':    // Tense, jpPropの一部を拡張
  223.         *extendFlag = TRUE;
  224.         break;
  225.     case 'v':    // Make VISIBLE
  226.         *prtControl = PRT_CONTROL_UNCONDITIONAL;
  227.         break;
  228.     case 'x':    // JP_KIND_FALLOIR用
  229.         if(p->jpProp & JP_PROP_NEGATIVE)
  230.             *jpChange = JP_CHANGE_PLEASE;
  231.         else
  232.             *jpChange = JP_CHANGE_ADJECTIVE;
  233.         break;
  234.     case 'y':    // JP_KIND_DEVOIR用
  235.         if(p->jpProp & JP_PROP_NEGATIVE)
  236.             *jpChange = JP_CHANGE_NEGATIVE;
  237.         else
  238.             *jpChange = JP_CHANGE_ADJECTIVE;
  239.         break;
  240.     case 'z':
  241.         *jpChange = JP_CHANGE_CONT;
  242.         break;
  243.     default:
  244.         return(FALSE);
  245.     }
  246.     return(TRUE);
  247. }
  248.  
  249. //
  250. // 動詞（＋目的語１＋目的語２）を表示
  251. //
  252. void
  253. PrintOutVerb(TOKEN *subject, TOKEN *verb, JP_CHANGE jpChange)
  254. {
  255.     if(verb == NULL) {
  256.         PrintOutTokens(NULL, subject, JP_CHANGE_NONE);
  257.         return;
  258.     }
  259.  
  260.     if(verb->prtControl & PRT_CONTROL_DISPLAYED)
  261.         return;
  262.  
  263.     JP_VERB    const    *jpVerb = (JP_VERB *)verb->which;
  264.  
  265.     if(jpVerb == NULL) {        // 最後の候補 = 一番つぶしが効く？
  266.         VERB    *dic = (VERB *)verb->what;
  267.         jpVerb    = &(dic->jpVerb)[dic->proposed - 1];
  268.     }
  269.  
  270.     // Il n'y a plus de neige. もっと雪がない -> もう雪がない
  271.     // <雪>がJP_PROP_NEGATIVEを持っていなければならない
  272.     if(verb->object1 && (verb->object1->frPart & FR_PART_NOUN))
  273.         ExtendTense(verb, verb->object1);
  274.     if(verb->object2 && (verb->object2->frPart & FR_PART_NOUN))
  275.         ExtendTense(verb, verb->object2);
  276.  
  277.     if(verb->child)
  278.         SortToken(verb->child, verbSortTable);
  279.  
  280.     char    str_sub[100], str_obj[100], str_verb[100];
  281.     DevideVerbJapanese(jpVerb->japanese, str_sub, str_obj, str_verb);
  282.  
  283.     int    cntSubject = 0;
  284.     if(subject)    cntSubject = CountTokensWChild(subject->child);
  285.  
  286.     // 文章本体の前に、表示すべきもの
  287.     for(TOKEN *p = verb->child; p; p = p->next) {
  288.         if(ShallPrintOutBeforeVerb(p)) {
  289.             p->jpEmphasis |= JP_EMPHASIS_COMMA;
  290.             PrintOutToken(verb, p, JP_CHANGE_ADVERB);
  291.         }
  292.     }
  293.  
  294.     if(CountTokensWChild(verb->child) >= cntSubject + 3
  295.     || (jpVerb->jpHint & JP_HINT_EXADVERB1)) {
  296.         // 副詞１、主語、副詞２、目的語の順に表示
  297.         PrintOutTokens(verb, verb->child, JP_CHANGE_CONT, LeaveOneAdverb);
  298.         PrintOutSubjectObject(str_sub, str_obj, subject, verb);
  299.     } else {
  300.         // 主語、目的語、副詞の順に表示
  301.         PrintOutSubjectObject(str_sub, str_obj, subject, verb);
  302.     }
  303.     PrintOutTokens(verb, verb->child, JP_CHANGE_ADVERB);
  304.  
  305.     PrintOutMacroStr(str_verb, subject, verb, jpChange);
  306.     PrintOutVerbTail3(verb, jpVerb->jpKind, jpChange);
  307.  
  308.     if(IsObjectMatch(verb->frPart, FR_PART_SENTENCE_QUE)
  309.     && verb->prtControl == PRT_CONTROL_ENABLE)    // != PRT_CONTROL_REPLACED
  310.         MyPrintf("事");
  311. }
  312.  
  313. // 文章の前に表示する副詞の中で、最後のTokenを探す
  314. TOKEN
  315. *GetLastFrontAdverb(TOKEN *start)
  316. {
  317.     TOKEN    *p;
  318.     TOKEN    *last = NULL;
  319.  
  320.     for(p = start; p; p = p->next) {
  321.         if(LeaveOneAdverb(p)) last = p;
  322.     }
  323.     return(last);
  324. }
  325.  
  326. // 文章本体の前に、表示したほうが良いか？
  327. BOOL
  328. ShallPrintOutBeforeVerb(TOKEN *p)
  329. {
  330.     if(IsObjectMatch(p, FR_PART_INDEPENDENCE_ALL))
  331.         return(TRUE);
  332.     if(p->jpEmphasis & JP_EMPHASIS_COMMA)
  333.         return(TRUE);
  334.  
  335.     // 文章を従えた前置詞
  336.     if((p->frPart & FR_PART_PREPOSIT)
  337.     &&  p->object1
  338.     && (p->object1->frPart & FR_PART_VERB))
  339.         return(TRUE);
  340.  
  341.     // 私は何度この詩集を読んだだろう! -> 何度、私はこの詩集を読んだだろう！
  342.     if(IsObjectMatch(p, FR_PART_ADVERB_EXCLAMINATION)
  343.     || SearchToken(FR_PART_ADVERB_EXCLAMINATION, p->child))
  344.         return(TRUE);
  345.  
  346.     if((p->frPart & FR_PART_INTERROGATIVE)
  347.     || (p->frPart & FR_PART_COMBINE)
  348.     || IsObjectMatch(p, FR_PART_PREPOSIT_PAR)
  349.     || HasRelative(p))
  350.         return(TRUE);
  351.  
  352.     // 埋め込むには、長すぎる
  353.     if(CountTokensWChild(p->child)
  354.     +  CountTokensWChild(p->subject)
  355.     +  CountTokensWChild(p->object1)
  356.     +  CountTokensWChild(p->object2) >= 4) {
  357.         p->jpEmphasis |= JP_EMPHASIS_COMMA;
  358.         return(TRUE);
  359.     }
  360.  
  361.     return(FALSE);
  362. }
  363.  
  364. // 1つのTOKENを残しているか？
  365. // eg) ウィーンで、<1827年3月26日>、彼は死んだ
  366. // ->  ウィーンで、彼は<1827年3月26日>死んだ
  367. BOOL
  368. LeaveOneAdverb(TOKEN *p)
  369. {
  370.     TOKEN    *q = p->next;
  371.  
  372.     while(q) {
  373.         if(CanBeLastAdverb(q))
  374.             return(TRUE);
  375.         q = q->next;
  376.     }
  377.     return(FALSE);
  378. }
  379.  
  380. BOOL
  381. CanBeLastAdverb(TOKEN *p)
  382. {
  383.     if((p->jpEmphasis & JP_EMPHASIS_COMMA)
  384.     || (p->prtControl & PRT_CONTROL_DISABLE)
  385.     || (p->prtControl & PRT_CONTROL_DISPLAYED))
  386.         return(FALSE);
  387.  
  388.     if((p->frPart & FR_PART_ADVERB)
  389.     || (p->frPart & FR_PART_ADJECTIVE)
  390.     || (p->frPart & FR_PART_PREPOSIT)
  391.     || IsObjectMatch(p, FR_PART_NOUN_GENERAL))
  392.         return(TRUE);
  393.  
  394.     return(FALSE);
  395. }
  396.  
  397. void
  398. PrintOutSubjectObject(char *str_sub, char *str_obj, TOKEN *subject, TOKEN *verb)
  399. {
  400.     int    cntObjects =  CountTokensWChild(verb->object1)
  401.                     + CountTokensWChild(verb->object2);
  402.  
  403.     if(verb->object1
  404.     &&  (SearchToken(FR_PART_SENTENCE_ALL, verb->object1)    // 助動詞を含まない
  405.       || SearchToken(FR_PART_RELATIVE_ALL, verb->object1->child)))
  406.         cntObjects += 10;
  407.     if(verb->object2
  408.     &&  (SearchToken(FR_PART_VERB_ALL, verb->object2)    // 近く動詞を含む
  409.       || SearchToken(FR_PART_RELATIVE_ALL, verb->object2->child)))
  410.         cntObjects += 10;
  411.  
  412.     if(subject
  413.     && *str_sub
  414.     && subject->prtControl == PRT_CONTROL_ENABLE
  415.     && cntObjects >= 7) {
  416.         PrintOutMacroStr(str_obj, subject, verb, JP_CHANGE_NONE);
  417.         if(verb->synSubject    // 何をするのかを、知らず　-> 何をするのかを知らず 
  418.         && cntObjects >= 6)
  419.             MyPrintf("、");
  420.         PrintOutMacroStr(str_sub, subject, verb, JP_CHANGE_NONE);
  421.     } else {
  422.         PrintOutMacroStr(str_sub, subject, verb, JP_CHANGE_NONE);
  423.         PrintOutMacroStr(str_obj, subject, verb, JP_CHANGE_NONE);
  424.     }
  425. }
  426.  
  427. //
  428. // "."を手がかりに文字列を分割
  429. //
  430. void
  431. DevideVerbJapanese(char *japanese, char *subject, char *object, char *verb)
  432. {
  433.     char    *s = japanese,
  434.             *p = verb;
  435.  
  436.     subject[0] = object[0] = verb[0] = '\0';
  437.  
  438.     while(TRUE) {
  439.         *p = *s;
  440.         if(*s == '\0')
  441.             break;
  442.         if(*s == '.') {
  443.             s++; *p = '\0';
  444.             p = verb;
  445.             if(subject[0])
  446.                 PrintInternalError( "Internal Error <DevideVerbJapanese> <%s>\n", japanese);
  447.             if(object[0])
  448.                 strcpy(subject, object);
  449.             strcpy(object, verb);
  450.         } else {
  451.             p++; s++;
  452.         }
  453.     }
  454. }
  455.  
  456.  
  457. //
  458. // 動詞情報の拡張などを行ってから、日本語を表示
  459. //
  460. void
  461. PrintOutVerbTail3(TOKEN *p, JP_KIND jpKind, JP_CHANGE jpChange)
  462. {
  463.     FR_ATTRIB    frAttrib    = p->frAttrib;
  464.     FR_TENSE    frTense        = p->frTense;
  465.     JP_PROP        jpProp        = p->jpProp;
  466.     JP_EMPHASIS    jpEmphasis = p->jpEmphasis;
  467.  
  468.     TOKEN    *from;
  469.  
  470.     for(from = p->jpExtendFrom; from; from = from->jpExtendFrom) {
  471.         if(from->frAttrib)    frAttrib = from->frAttrib;
  472.         if(from->frTense)    frTense  = from->frTense;
  473.         jpProp     = jpProp | (from->jpProp * JP_PROP_NEGATIVE);
  474.         jpEmphasis |= from->jpEmphasis;
  475.     }
  476.  
  477.     //　動詞は、各自が持っている時勢を使う
  478.     if( (p->frPart & FR_PART_VERB)
  479.     && !(p->frTense & FR_TENSE_ORIGIN)) {
  480.         frAttrib = p->frAttrib;
  481.         frTense = p->frTense;
  482.     }
  483.  
  484.     PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, jpChange, jpEmphasis, TRUE);
  485. }
  486.  
  487.  
  488. //
  489. // S V A, S V O Aのように形容詞・副詞で言い切る日本語訳に備えて
  490. // Aにも必要な情報をＶから供給する
  491. //
  492. void
  493. ExtendTense(TOKEN *verb, TOKEN *object)
  494. {
  495.     if(object == NULL)    return;
  496.  
  497.     object->jpProp    |= (verb->jpProp * (JP_PROP_NEGATIVE | JP_PROP_QUESTION));
  498.     object->jpExtendFrom = verb;
  499. }
  500.  
  501. //
  502. // マクロ文字列を表示
  503. //
  504. void
  505. PrintOutMacroStr(char *ptr, TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  506. {
  507.     unsigned char    prevChar = '\0';    // 直前のキャラクタ(Shift JIS判別用)
  508.     PRT_CONTROL    prtControl = PRT_CONTROL_ENABLE;
  509.     JP_EMPHASIS    jpEmphasis = JP_EMPHASIS_NONE;
  510.     JP_CHANGE    savJpChange = jpChange;        // JP_CHANGEを保存
  511.     BOOL        extendFlag = FALSE;    // frTense, jpPropの一部を拡張するか？
  512.  
  513.     while(*ptr) {
  514.         if((0x80 <= prevChar && prevChar <= 0x9f)
  515.         || (0xe0 <= prevChar && prevChar <= 0xff)) {
  516.             prevChar = '\0';
  517.             MyPrintf("%c", *ptr++);    // ２バイトコードの２バイト目
  518.         } else if(*ptr == '%') {
  519.             if(ptr[1] == '%')    {
  520.                 MyPrintf("%%");
  521.                 ptr += 2;
  522.             } else {
  523.                 while(1) {
  524.                     if(*++ptr == '0') {
  525.                         if(extendFlag)    ExtendTense(p, p->subject);
  526.                         if(p->synSubject) {
  527.                             PrintOutMacroStr2(parent, p->subject, jpChange, &jpEmphasis, &prtControl);
  528.                         } else {
  529.                             prtControl = PRT_CONTROL_DISABLE;
  530.                         }
  531.                         extendFlag = FALSE;
  532.                         jpChange = savJpChange;
  533.                     } else if(*ptr == '1') {
  534.                         if(extendFlag)    ExtendTense(p, p->object1);
  535.                         PrintOutMacroStr2(parent, p->object1, jpChange, &jpEmphasis, &prtControl);
  536.                         extendFlag = FALSE;
  537.                         jpChange = savJpChange;
  538.                     } else if(*ptr == '2') {
  539.                         if(extendFlag)    ExtendTense(p, p->object2);
  540.                         PrintOutMacroStr2(parent, p->object2, jpChange, &jpEmphasis, &prtControl);
  541.                         extendFlag = FALSE;
  542.                         jpChange = savJpChange;
  543.                     } else if(*ptr == '3') {
  544.                         if(extendFlag)    ExtendTense(p, p->child);
  545.                         PrintOutMacroStr2(parent, p->child, jpChange, &jpEmphasis, &prtControl);
  546.                         extendFlag = FALSE;
  547.                         jpChange = savJpChange;
  548.                     } else if(PrintOutJpPreposition(ptr, jpEmphasis, prtControl)) {
  549.                         jpEmphasis = JP_EMPHASIS_NONE;
  550.                         if(*ptr == '<') {
  551.                             while(*ptr && *ptr != '>')    ptr++;
  552.                         }
  553.                     } else if(SetJpChange(*ptr, p, &jpChange, &prtControl, &extendFlag)) {
  554.                     } else
  555.                         break;
  556.                 }
  557.             }
  558.         } else {
  559.             MyPrintf("%c", *ptr);
  560.             prevChar = *ptr++;    // １文字前のキャラクタ
  561.         }
  562.     }
  563. }
  564.  
  565. void
  566. PrintOutMacroStr2(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange, JP_EMPHASIS *jpEmphasis, PRT_CONTROL *prtControl)
  567. {
  568.     if(p == NULL
  569.     || (p->prtControl & PRT_CONTROL_DISPLAYED)) {
  570.         *prtControl = PRT_CONTROL_DISABLE;
  571.     } else {
  572.         PRT_CONTROL    savControl = p->prtControl;
  573.  
  574.         if(*prtControl == PRT_CONTROL_UNCONDITIONAL)
  575.             p->prtControl = PRT_CONTROL_ENABLE;
  576.         PrintOutTokens(parent, p, jpChange);
  577.         p->prtControl = PRT_CONTROL_DISPLAYED;
  578.         *jpEmphasis = p->jpEmphasis;
  579.         *prtControl = savControl;
  580.     }
  581. }
  582.  
  583. //
  584. // 動詞の活用を表示(再帰構造）
  585. //
  586. void
  587. PrintOutVerbTail2(JP_KIND jpKind, FR_ATTRIB frAttrib, FR_TENSE frTense, JP_PROP jpProp, JP_CHANGE jpChange, JP_EMPHASIS jpEmphasis, BOOL isRoot)
  588. {
  589.     JP_KIND    jpKindTail = JP_KIND_NONE;    // 助動詞の種類
  590.  
  591.     if(jpEmphasis & JP_EMPHASIS_NOTAIL)    return;
  592.  
  593.     if((frTense & FR_TENSE_ORDER)
  594.     && jpChange == JP_CHANGE_STOP) {    // <voir> Paris et mourir.    パリを<見よう> -> パリを<見て>
  595.         PrintOutVerbOrder(jpKind, frAttrib, frTense, jpProp, jpChange, isRoot);
  596.     } else if(jpProp & JP_PROP_QUESTION) {
  597.         jpProp &= (~JP_PROP_QUESTION);
  598.         PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_QUESTION, jpEmphasis, FALSE);
  599.         if(jpKind != JP_KIND_NONE) {
  600.             if(jpChange == JP_CHANGE_EXCLAME)    MyPrintf("の");    // Combien de temps n'avons-nous pas perdu! 我々はなんて多くの時間を失った<か→の>だろう！ 
  601.             else                                MyPrintf("か");
  602.         }
  603.     } else if(frTense & FR_TENSE_FUTURE_SIMPLE) {
  604.         frTense = (FR_TENSE)(frTense & (~FR_TENSE_FUTURE_SIMPLE));
  605.         PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_STOP, jpEmphasis, FALSE);
  606.         if(jpChange != JP_CHANGE_ADJECTIVE) {    // quand je rentrerai. 私が帰るだろう時 -> 私が帰る時
  607.             if(jpKind == JP_KIND_DA || jpKind == JP_KIND_KEIYODOSHI || jpKind == JP_KIND_RENTAISHI)
  608.                 MyPrintf("ろう");
  609.             else if(jpKind != JP_KIND_NONE)
  610.                 MyPrintf("だろう");
  611.         }
  612.         jpKindTail = JP_KIND_NONE;
  613.     } else if((frTense & FR_TENSE_PASSE)
  614.             && jpChange != JP_CHANGE_ADVERB        // <して> の過去形も<して>
  615.             && jpChange != JP_CHANGE_RESPECT) {    // 閉じ込められた<れた> -> 閉じ込められた
  616.         frTense = (FR_TENSE)(frTense & (~FR_TENSE_PASSE));
  617.         if(jpChange == JP_CHANGE_IF) {    // <すれば>の過去形<していれば>
  618.             frTense = (FR_TENSE)(frTense & (~FR_TENSE_PROGRESSIVE));
  619.             if((jpKind & 0xfff0) == JP_KIND_IRU
  620.             || (jpKind & 0xfff0) == JP_KIND_GODAN2) {    // 動詞自体に＜いる＞が含まれる場合は､無視 eg)知っている
  621.                 PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_IF, jpEmphasis, FALSE);
  622.             } else {
  623.                 PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_PLEASE, jpEmphasis, FALSE);
  624.                 jpKindTail = JP_KIND_IRU;
  625.             }
  626.         } else if(jpChange == JP_CHANGE_CONT) {
  627.             PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_CONT, jpEmphasis, FALSE);
  628.         } else {
  629.             PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_PASSE, jpEmphasis, FALSE);
  630.         }
  631. //        if(jpKind != JP_KIND_NONE)    MyPrintf("た");
  632.     } else if((frTense & FR_TENSE_PROGRESSIVE)
  633.             && !(jpProp & JP_PROP_CONDITION)) {    // ～している
  634.         frTense = (FR_TENSE)(frTense & (~FR_TENSE_PROGRESSIVE));
  635.         PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_PLEASE, jpEmphasis, FALSE);
  636.         jpKindTail = JP_KIND_IRU;
  637.     } else if(jpProp & JP_PROP_NEGATIVE) {
  638.         jpProp &= (~JP_PROP_NEGATIVE);
  639.         PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_NEGATIVE, jpEmphasis, FALSE);
  640.         if(!(jpKind == JP_KIND_DEVOIR && isRoot)    // しなくてもよ/い
  641.         && jpKind != JP_KIND_NONE) {
  642.             MyPrintf("な");        // ない
  643.             jpKindTail = JP_KIND_KEIYOSHI;
  644.         } else {
  645.             jpKindTail = JP_KIND_KEIYOSHI;
  646.         }
  647.     } else if(jpProp & JP_PROP_PASSIVE) {    // 受け身
  648.         jpProp &= (~JP_PROP_PASSIVE);
  649.         PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_RESPECT, jpEmphasis, FALSE);
  650.         if(jpChange != JP_CHANGE_RESPECT) {    // 閉じ込められ<られ>
  651.             jpKindTail = JP_KIND_RERU;
  652.         }
  653.     } else if(jpEmphasis & JP_EMPHASIS_NI) {
  654.         jpEmphasis -= JP_EMPHASIS_NI;
  655.         PrintOutVerbTail2(jpKind, frAttrib, frTense, jpProp, JP_CHANGE_MO, jpEmphasis, FALSE);
  656.     } else {
  657.         PrintOutJpChange(jpKind, jpChange);
  658.     }
  659.  
  660.     if(jpKind != JP_KIND_NONE
  661.     && jpKindTail != JP_KIND_NONE) 
  662.         PrintOutJpChange(jpKindTail, jpChange);
  663. }
  664.  
  665. //
  666. // 命令形の表示
  667. //
  668. void
  669. PrintOutVerbOrder(JP_KIND jpKind, FR_ATTRIB frAttrib, FR_TENSE frTense, JP_PROP jpProp, JP_CHANGE jpChange, BOOL isRoot)
  670. {
  671.     if(jpKind == JP_KIND_NONE
  672.     || jpChange == JP_CHANGE_NONE)
  673.         return;
  674.  
  675.     if(!(frAttrib & FR_ATTRIB_PLURAL)        // tu 
  676.     || (frTense & FR_TENSE_ORIGIN)) {        // 原形
  677.         if(jpProp & JP_PROP_NEGATIVE) {
  678.             jpProp &= (~JP_PROP_NEGATIVE);
  679.             PrintOutVerbTail2(jpKind, frAttrib, FR_TENSE_NONE, jpProp, JP_CHANGE_STOP, JP_EMPHASIS_NONE, FALSE);
  680.             MyPrintf("な");
  681.         } else {
  682.             PrintOutVerbTail2(jpKind, frAttrib, FR_TENSE_NONE, jpProp, JP_CHANGE_ORDER, JP_EMPHASIS_NONE, FALSE);
  683.         }
  684.     } else if((frAttrib & FR_ATTRIB_PLURAL)        // vous
  685.     && (frAttrib & FR_ATTRIB_LEVEL2)) {
  686.         if(jpProp & JP_PROP_NEGATIVE) {
  687.             PrintOutVerbTail2(jpKind, frAttrib, FR_TENSE_NONE, jpProp, JP_CHANGE_STOP, JP_EMPHASIS_NONE, FALSE);
  688.             MyPrintf("で下さい");
  689.         } else {
  690.             PrintOutVerbTail2(jpKind, frAttrib, FR_TENSE_NONE, jpProp, JP_CHANGE_PLEASE, JP_EMPHASIS_NONE, FALSE);
  691.             MyPrintf("下さい");
  692.         }
  693.     } else if(jpKind != JP_KIND_NONE) {    // nous
  694.         if(jpProp & JP_PROP_NEGATIVE) {
  695.             PrintOutVerbTail2(jpKind, frAttrib, FR_TENSE_NONE, jpProp, JP_CHANGE_ADJECTIVE, JP_EMPHASIS_NONE, FALSE);
  696.             MyPrintf("ようにしましょう");
  697.         } else {
  698.             PrintOutVerbTail2(jpKind, frAttrib, FR_TENSE_NONE, jpProp, JP_CHANGE_LETS, JP_EMPHASIS_NONE, FALSE);
  699.             MyPrintf("う");
  700.         }
  701.     }
  702. }
  703.  
  704. //
  705. // Token Listを表示
  706. //
  707. int
  708. PrintOutTokens(TOKEN *parent, TOKEN *start, JP_CHANGE jpChange, BOOL (*Eval)(TOKEN *))
  709. {
  710.     TOKEN    *p;
  711.     int        cnt = 0;
  712.  
  713.     for(p = start; p; p = p->next) {
  714.         if(Eval == NULL
  715.         || (Eval)(p)) {
  716.             PrintOutToken(parent, p, jpChange);
  717.             cnt++;
  718.         }
  719.     }
  720.     return(cnt);
  721. }
  722.  
  723. //
  724. // TOKENを表示
  725. //
  726. void
  727. PrintOutToken(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  728. {
  729.     FR_PART    frPart = p->frPart;
  730.  
  731.     if(frPart & FR_PART_COMBINE)        PrintOutCombine(parent, p, jpChange);
  732.     else if(frPart & FR_PART_ARTICLE)    PrintOutArticle(parent, p);
  733.     else if(frPart & FR_PART_VERB)        PrintOutVerb(p->subject, p, jpChange);
  734.     else if(frPart & FR_PART_PREPOSIT)    PrintOutPreposition(parent, p, jpChange);
  735.     else if(frPart & FR_PART_ADJECTIVE)    PrintOutAdjective(parent, p, jpChange);
  736.     else if(frPart & FR_PART_ADVERB)    PrintOutAdverb(parent, p, jpChange);
  737.     else if(frPart & FR_PART_NOUN)        PrintOutNoun(parent, p);
  738.     else if(frPart & FR_PART_NUMETRIC)    PrintOutNumetric(parent, p, jpChange);
  739.     else if(frPart & FR_PART_RELATIVE)    PrintOutRelative(parent, p, jpChange);
  740.     else if(frPart & FR_PART_INTERROGATIVE)    PrintOutInterrogative(parent, p, jpChange);
  741.     else if(frPart & FR_PART_SPECIAL)    PrintOutSpecial(parent, p, jpChange);
  742.     else if(frPart & FR_PART_INDEPENDENCE)    PrintOutIndependence(parent, p, jpChange);
  743.     else if(frPart & FR_PART_CONJUNCTION) PrintOutConjunction(parent, p, jpChange);
  744.  
  745.     if( p->prtControl == PRT_CONTROL_ENABLE
  746.     && IsObjectMatch(p, FR_PART_NUMETRIC_ALL) == FALSE
  747.     && (p->jpEmphasis & JP_EMPHASIS_COMMA))
  748.         MyPrintf("、");
  749.  
  750.     p->prtControl = PRT_CONTROL_DISPLAYED;
  751. }
  752.  
  753.  
  754. //
  755. // 日本語動詞語尾の表示
  756. //
  757. void
  758. PrintOutJpChange(JP_KIND jpKind, JP_CHANGE jpChange)
  759. {
  760.     char    tmp[10], *ret;
  761.  
  762.     if(jpChange == JP_CHANGE_NONE)    return;
  763.  
  764.     switch(jpKind & (~0xf)) {
  765.       case JP_KIND_NONE:    // 何もしない
  766.         return;
  767.       case JP_KIND_GODAN:    // 五段活用
  768.         ret = (char *)jpVerbTailTable_Godan[jpKind & 0x0f][jpChange];
  769.         break;
  770.       case JP_KIND_GODAN2:    // 否定:五段活用/肯定:上一段活用 eg)知っている/知らない
  771.         if(jpChange == JP_CHANGE_NEGATIVE) {
  772.             ret = (char *)jpVerbTailTable_Godan[jpKind & 0x0f][jpChange];
  773.         } else {
  774.             strcpy(tmp, "ってい");
  775.             strcat(tmp, (char *)jpVerbTailTable_Other[jpChange]);
  776.             ret = tmp;
  777.         }
  778.         break;
  779.       case JP_KIND_IRU:            // 上一段活用
  780.         strcpy(tmp, (char *)jpVerbTailTable_Upper1[jpKind & 0x0f]);
  781.         strcat(tmp, (char *)jpVerbTailTable_Other[jpChange]);
  782.         ret = tmp;
  783.         break;
  784.       case JP_KIND_SHIMOICHI:    // 下一段活用
  785.         strcpy(tmp, (char *)jpVerbTailTable_Lower1[jpKind & 0x0f]);
  786.         strcat(tmp, (char *)jpVerbTailTable_Other[jpChange]);
  787.         ret = tmp;
  788.         break;
  789.       case JP_KIND_SHIMOICHI2:    // 下一段活用 （その２） 失う恋 -> 失われた恋
  790.         strcpy(tmp, (char *)jpVerbTailTable_Lower1[jpKind & 0x0f]);
  791.         strcat(tmp, (char *)jpVerbTailTable_Other2[jpChange]);
  792.         ret = tmp;
  793.         break;
  794.       case JP_KIND_NOROOT:    // 語幹なし上/下一段活用
  795.         ret = (char *)jpVerbTailTable_Noroot[jpChange];
  796.         break;
  797.       case JP_KIND_KAHEN:        // カ行変格活用
  798.         ret =  (char *)jpVerbTailTable_Kahen[jpChange];
  799.         break;
  800.       case JP_KIND_SAHEN:        // サ行変格活用
  801.         ret = (char *)jpVerbTailTable_Sahen[jpChange];
  802.         break;
  803.       case JP_KIND_SAHEN2:        // サ行変格活用（その２）    怪我をする人 -> 怪我をした人
  804.         ret = (char *)jpVerbTailTable_Sahen2[jpChange];
  805.         break;
  806.       case JP_KIND_KEIYOSHI:    // 形容詞
  807.         ret = (char *)jpVerbTailTable_Keiyoshi[jpChange];
  808.         break;
  809.       case JP_KIND_KEIYODOSHI:    // 形容動詞
  810.         ret = (char *)jpVerbTailTable_KeiyoDoshi[jpChange];
  811.         break;
  812.       case JP_KIND_RENTAISHI:    // 連体詞
  813.         ret = (char *)jpVerbTailTable_Rentaishi[jpChange];
  814.         break;
  815.       case JP_KIND_ADVERB:        // 副詞
  816.         ret = (char *)jpVerbTailTable_Adverb[jpChange];
  817.         break;
  818.       case JP_KIND_ARU:            // 在る
  819.         ret = (char *)jpVerbTailTable_Aru[jpChange];
  820.         break;
  821.       case JP_KIND_MASU:        // ます
  822.         ret = (char *)jpVerbTailTable_Masu[jpChange];
  823.         break;
  824.       case JP_KIND_RASII:        // らしい
  825.         ret = (char *)jpVerbTailTable_Rasii[jpChange];
  826.         break;
  827.       case JP_KIND_TA:            // た
  828.         ret = (char *)jpVerbTailTable_Ta[jpChange];
  829.         break;
  830.       case JP_KIND_DA:            // だ
  831.         ret = (char *)jpVerbTailTable_Da[jpChange];
  832.         break;
  833.       case JP_KIND_DESU:        // です
  834.         ret = (char *)jpVerbTailTable_Desu[jpChange];
  835.         break;
  836.       case JP_KIND_DEVOIR:
  837.         ret = (char *)jpVerbTailTable_Devoir[jpChange];
  838.         break;
  839.       case JP_KIND_FALLOIR:
  840.         ret = (char *)jpVerbTailTable_Falloir[jpChange];
  841.         break;
  842.       case JP_KIND_POUVOIR:
  843.         ret = (char *)jpVerbTailTable_Pouvoir[jpChange];
  844.         break;
  845.       default:
  846.           goto Error;
  847.     }
  848.     MyPrintf(ret);
  849.     return;
  850. Error:
  851.     PrintInternalError( "Internal Error <PrintOutJpChange>\n"
  852.                     " jpKind = %x\n", jpKind);
  853.     TermProgram(-1);
  854. }
  855.  
  856.  
  857.  // 冠詞の表示
  858. void
  859. PrintOutArticle(TOKEN *parent, TOKEN *p)
  860. {
  861.     if(p->prtControl != PRT_CONTROL_ENABLE)    return;
  862.  
  863.     if(parent
  864.     && parent->frPart == FR_PART_NOUN_GENERAL) {
  865.         if(parent->jpProp & JP_PROP_DATE) {
  866.             if(parent->jpProp & JP_PROP_UNIQUE)    MyPrintf("毎");    // le mandi -> 毎月曜日
  867.             // JP_PROP_DATE without JP_PROP_UNIT should be "month"
  868.             return;
  869.         }
  870.         // la Terre (その)地球 -> 地球
  871.         // la livre (その)ポンド -> ポンド
  872.         if(parent->jpProp & (JP_PROP)(JP_PROP_UNIQUE | JP_PROP_UNIT))
  873.             return;
  874.     }
  875.  
  876.     if(p->frPart == FR_PART_ARTICLE_INFINIT
  877.     &&(p->frAttrib & FR_ATTRIB_PLURAL)
  878.     && parent
  879.     && parent->frPart == FR_PART_NOUN_GENERAL) {
  880.         // des petits livres.
  881.         char    *s = GetJpUnit(((JP_NOUN *)parent->which)->jpUnit);
  882.         if(*s)    MyPrintf("(何%sかの)", s);
  883.         else    MyPrintf("(幾らかの)");
  884.     } else if(p->frPart == FR_PART_ARTICLE_PARTIAL) {
  885. //        MyPrintf("(幾らかの)");
  886.     }else {
  887.         MyPrintf(((ARTICLE *)p->what)->japanese);
  888.     }
  889. }
  890.  
  891. // 名詞にかかる言葉の優先順位
  892. // eg) 若いどの少女 → どの若い少女？
  893. FR_PATTERN    nounSortTable[] = {
  894.     FR_PATTERN( CMP_TOKEN(  FR_PART_ARTICLE_ALL),                1 ),
  895.     FR_PATTERN( CMP_TOKEN(  FR_PART_INTERROGATIVE_ALL),            2 ),
  896.     FR_PATTERN( CMP_TOKEN(  FR_PART_ADJECTIVE_GENERAL_B),        3 ),
  897.     FR_PATTERN( CMP_TOKEN(  FR_PART_ADJECTIVE_EXCLAMINATION),    7 ),
  898.     FR_PATTERN( CMP_TOKEN(  FR_PART_ADJECTIVE_ALL),                4 ),
  899.     FR_PATTERN( CMP_TOKEN(  FR_PART_ALL),                           5 ),
  900.     FR_PATTERN( CMP_TOKEN(  FR_PART_NUMETRIC_ALL),                6 ),
  901.     FR_PATTERN( CMP_TOKEN(  FR_PART_VERB_ALL),                    7 ),
  902.     FR_PATTERN( CMP_TOKEN(  FR_PART_RELATIVE_ALL),                8 ),
  903.     FR_PATTERN( CMP_TOKEN(  FR_PART_NONE )),
  904. };
  905.  
  906. //
  907. // 名詞の表示
  908. //
  909. void
  910. PrintOutNoun(TOKEN *parent, TOKEN *p)
  911. {
  912.     if(p->frPart & FR_PART_COMBINE) {
  913.         if(p->object1)    PrintOutNoun(parent, p->object1);
  914.         if(p->object2)    PrintOutNoun(parent, p->object2);
  915.         return;
  916.     }
  917.  
  918.     if(p->frPart == FR_PART_NOUN_VERB) {
  919.         JP_EMPHASIS        savJpEmphasis = p->jpEmphasis;
  920.         p->jpEmphasis -= JP_EMPHASIS_NI;
  921.         PrintOutVerb(NULL, p, JP_CHANGE_ADJECTIVE);
  922.         if(p->prtControl == PRT_CONTROL_ENABLE)    // != PRT_CONTROL_REPLACED
  923.             MyPrintf("事");
  924.  
  925.         p->jpEmphasis = savJpEmphasis;
  926.         if(savJpEmphasis & JP_EMPHASIS_NI)    MyPrintf("も");
  927.         return;
  928.     }
  929.  
  930.     if(p->child) {
  931.         SortToken(p->child, nounSortTable);
  932. //        PrintOutTokens(NULL, p->child, FR_PART_VERB, JP_CHANGE_ADJECTIVE);
  933.         PrintOutTokens(p, p->child, JP_CHANGE_ADJECTIVE);
  934.     }
  935.  
  936.     if(p->prtControl != PRT_CONTROL_ENABLE)
  937.         return;
  938.  
  939.     if((p->jpProp & JP_PROP_DATE) && p->value2)
  940.         MyPrintf("%d年", p->value2);
  941.  
  942.     if(p->frPart == FR_PART_NOUN_GENERAL) {
  943.         PrintOutGeneralNoun(parent, p);
  944.     } else {
  945.         PrintOutPronoun(parent, p);
  946.     }
  947.  
  948.     // 最も美しい街の一つ
  949.     if(IsWordOwner(p, FR_ATTRIB_ONE_OF)) {
  950.         char    *unit = GetJpUnit(p->jpUnit);
  951.         if(unit[0] == '\0')    unit = "つ";
  952.         MyPrintf("の1%s", unit);
  953.     }
  954.     if(IsObjectMatch(p, FR_PART_NOUN_PERSONAL)
  955.     && (p->jpEmphasis & JP_EMPHASIS__MEME)) {
  956.         // moi-m]me.
  957.         MyPrintf("自身");
  958.     }
  959. }
  960.  
  961. void
  962. PrintOutPronoun(TOKEN *parent, TOKEN *p)
  963. {
  964.     if(p->which == NULL) {    // 日本語訳が確定していない時は、一番つぶしが効くものを
  965.         PRONOUN *pronoun = (PRONOUN *)p->what;
  966.         p->which = &pronoun->jpPronoun[pronoun->proposed-1];
  967.     }
  968.     if((p->jpEmphasis & JP_EMPHASIS_ROOT)
  969.     && (p->jpProp & JP_PROP_NEGATIVE)) {
  970.         void    *savWhich = p->which;
  971.         // Rien de autre. 他の誰 ->他の誰もいない。
  972.         SelectJpPronoun2(p, p->jpProp);
  973.         // 誰もいない<も> -> 誰もいない
  974.         if(savWhich != p->which)
  975.             p->jpEmphasis = JP_EMPHASIS_NONE;
  976.     }
  977.     JP_PRONOUN *jpPronoun = (JP_PRONOUN *)p->which;
  978.     MyPrintf(jpPronoun->japanese);
  979. }
  980.  
  981. void
  982. PrintOutGeneralNoun(TOKEN *parent, TOKEN *p)
  983. {
  984.     if(!strcmp("heure", GetTokenFrench(p))
  985.     && p->value2) {
  986.         if(p->value2 > 0)    MyPrintf("時%d分", p->value2);
  987.         else                MyPrintf("時%d分前", - p->value2);
  988.         return;
  989.     }
  990.     if(p->which == NULL) {    // 日本語訳が確定していない時は、一番つぶしが効くものを
  991.         NOUN *noun = (NOUN *)p->what;
  992.         p->which = &noun->jpNoun[noun->proposed-1];
  993.     }
  994.     PrintOutMacroStr(((JP_NOUN *)p->which)->japanese, NULL, p, JP_CHANGE_STOP);
  995.  
  996.     if(!(p->prtControl & PRT_CONTROL_NO_PLUS)) {
  997.         if(p->frAttrib & FR_ATTRIB_PLUS)    MyPrintf("以上");
  998.         if(p->frAttrib & FR_ATTRIB_MOINS)    MyPrintf("以下");
  999.     }
  1000.     if(p->object1
  1001.     && IsObjectMatch(p->object1, FR_PART_NOUN_GENERAL)) {        // 名 + 姓 ジュリアン<・ソレル>
  1002.         MyPrintf("･");
  1003.         PrintOutTokens(p, p->object1, JP_CHANGE_STOP);
  1004.     }
  1005.     if(p->object2
  1006.     && IsObjectMatch(p->object2, FR_PART_NOUN_GENERAL)) {        // 敬称など、 ポール<さん>
  1007.         PrintOutTokens(p, p->object2, JP_CHANGE_STOP);
  1008.     }
  1009.     if((p->jpProp & JP_PROP_DATE) && p->value)
  1010.         MyPrintf("%d日", p->value);
  1011. }
  1012.  
  1013. // 形容詞の表示
  1014. void
  1015. PrintOutAdjective(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1016. {
  1017.     if(p->prtControl != PRT_CONTROL_ENABLE)    return;
  1018.  
  1019.     if(IsObjectMatch(parent, FR_PART_SENTENCE_ALL)
  1020.     && jpChange == JP_CHANGE_CONT)
  1021.         jpChange = JP_CHANGE_ADVERB;    // 不幸<で> -> 不幸<に>
  1022.  
  1023.     if(IsObjectMatch(p, FR_PART_ADJECTIVE_GENERAL))
  1024.         PrintOutGeneralAdjective(parent, p, jpChange);
  1025.     else
  1026.         PrintOutProadjective(parent, p, jpChange);
  1027.  
  1028. }
  1029.  
  1030. void
  1031. PrintOutGeneralAdjective(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1032. {
  1033.     JP_ADJECTIVE *jpAdjective = (JP_ADJECTIVE *)p->which;
  1034.     if(jpAdjective == NULL) {    // 最後の候補 = 一番つぶしが効く
  1035.         ADJECTIVE    *dic = (ADJECTIVE *)p->what;
  1036.         jpAdjective = &dic->jpAdjective[dic->proposed - 1];
  1037.     }
  1038.  
  1039.     if(p->child
  1040.     && strstr(jpAdjective->japanese, "%c3") == NULL)        // とても彼が成功し嬉しい ->彼が成功しとても嬉しい
  1041.         PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1042.  
  1043.     // 比較級の表示
  1044.     if(SearchToken(FR_PART_CONJUNCTION_THAN, p->child) == NULL)
  1045.         PrintOutCompare(parent, p);
  1046.     PrintOutMacroStr(jpAdjective->japanese, NULL, p, JP_CHANGE_NONE);
  1047. //    PrintOutVerbTail2(jpAdjective->jpKind, p->frAttrib, p->frTense, p->jpProp, jpChange, p->jpEmphasis, TRUE);
  1048.     PrintOutVerbTail3(p, jpAdjective->jpKind, jpChange);
  1049. }
  1050.  
  1051. void
  1052. PrintOutProadjective(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1053. {
  1054.     if(p->child) 
  1055.         PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1056.  
  1057.     JP_PROADJECTIVE *jpAdjective = (JP_PROADJECTIVE *)p->which;
  1058.     if(jpAdjective == NULL) {    // 最後の候補 = 一番つぶしが効く
  1059.         PROADJECTIVE    *dic = (PROADJECTIVE *)p->what;
  1060.         jpAdjective = &dic->jpProadjective[dic->proposed - 1];
  1061.     }
  1062.     MyPrintf(jpAdjective->japanese);
  1063. }
  1064.  
  1065. //
  1066. // 比較級の表示
  1067. //
  1068. void
  1069. PrintOutCompare(TOKEN *parent, TOKEN *p)
  1070. {
  1071.     if(p == NULL)    return;
  1072.  
  1073.     if(p->frAttrib & FR_ATTRIB_PLUS) {
  1074.         TOKEN    *than = SearchToken(FR_PART_CONJUNCTION_THAN, p->child);
  1075.         if(than) {
  1076.             if(IsObjectMatch(than->object1, FR_PART_SENTENCE_NORMAL))
  1077.                 MyPrintf("から");
  1078.             else
  1079.                 MyPrintf("より");
  1080.             if(p->value != 0)    MyPrintf("%d倍", p->value);
  1081.         } else if(parent && (parent->jpProp & JP_PROP_NEGATIVE)
  1082.              || (p->jpProp & JP_PROP_NEGATIVE)) {
  1083.             MyPrintf("もう");
  1084.         } else {
  1085.             if(p->value != 0)    MyPrintf("%d倍", p->value);
  1086.             else                MyPrintf("もっと");
  1087.         }
  1088.     } else if(p->frAttrib & FR_ATTRIB_MOINS) {
  1089.         MyPrintf("より低度に");
  1090.     } else if(p->frAttrib & FR_ATTRIB_NE_MOINS) {
  1091.         MyPrintf("に劣らず");
  1092.     } else if(p->frAttrib & FR_ATTRIB_AUSSI) {
  1093.         TOKEN    *than = SearchToken(FR_PART_CONJUNCTION_THAN, p->child);
  1094.         if(than
  1095.         && than->object1 == NULL)
  1096.             MyPrintf("かつ");        // Marie est aussi inteligent que jolie.
  1097.         else
  1098.             MyPrintf("くらい");
  1099.     } else if(p->frAttrib & FR_ATTRIB_SI) {
  1100.         if(SearchToken(FR_PART_CONJUNCTION_THAN, p->child))
  1101.             MyPrintf("ほど");
  1102.         else
  1103.             MyPrintf("そんなに");
  1104.     } else if(p->frAttrib & FR_ATTRIB_LE_PLUS) {
  1105.         MyPrintf("最も");
  1106.     } else if(p->frAttrib & FR_ATTRIB_LE_MOINS) {
  1107.         MyPrintf("最も低度に");
  1108.     }
  1109. }
  1110.  
  1111. //
  1112. // 副詞の表示
  1113. //
  1114. void
  1115. PrintOutAdverb(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1116. {
  1117.     if(p->child)
  1118.         PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1119.  
  1120.     if(p->prtControl != PRT_CONTROL_ENABLE) return;
  1121.  
  1122.     if((p->frAttrib & FR_ATTRIB_COMPARE)
  1123.     && SearchToken(FR_PART_CONJUNCTION_THAN, p->child) == NULL)
  1124.         PrintOutCompare(parent, p);
  1125.     else if(p->frAttrib & FR_ATTRIB_TOP)
  1126.         PrintOutCompare(parent, p);
  1127.  
  1128.     if(p->frPart == FR_PART_ADVERB_ADVERB
  1129.     || p->frPart == FR_PART_ADVERB_EXCLAMINATION) {
  1130.         JP_PROADVERB *jpAdv = (JP_PROADVERB *)p->which;
  1131.         MyPrintf(jpAdv->japanese);
  1132.     } else if(p->frPart == FR_PART_ADVERB_PLUS) {
  1133.         if(IsWordOwner(p, FR_ATTRIB_COMPARE) == NULL
  1134.         && IsWordOwner(p, FR_ATTRIB_TOP) == NULL) {
  1135.             JP_PROADVERB *jpAdv = (JP_PROADVERB *)p->which;
  1136.             MyPrintf(jpAdv->japanese);
  1137.         }
  1138.     } else if(p->frPart == FR_PART_ADVERB_TOUT) {
  1139.         if(p->value)    MyPrintf("%d(つ/人)共", p->value);
  1140.         else            MyPrintf("全て");
  1141.     } else {
  1142.         JP_ADVERB *jpAdverb = (JP_ADVERB *)p->which;
  1143.         if(jpAdverb == NULL) {    // 最後の候補 = 一番つぶしが効く
  1144.             ADVERB    *dic = (ADVERB *)p->what;
  1145.             jpAdverb = &dic->jpAdverb[dic->proposed - 1];
  1146.         }
  1147.         if( (p->frPart & FR_PART_INTERROGATIVE)
  1148.         && !(p->jpProp & JP_PROP_NEGATIVE)) {    // eg) O| n'est pas la voiture? 車はどこにないか？
  1149.             // JP_PROP_QUESTIONなどを無視 eg) O| est la voiture? 車はどこか？ -> どこだ？
  1150.             MyPrintf(jpAdverb->japanese);
  1151.             PrintOutJpChange(jpAdverb->jpKind, jpChange);
  1152.         } else {
  1153.             PrintOutMacroStr((char *)jpAdverb->japanese, NULL, p, JP_CHANGE_NONE);
  1154.             PrintOutVerbTail3(p, jpAdverb->jpKind, jpChange);
  1155.         }
  1156.     }
  1157.     if(p->jpEmphasis & JP_EMPHASIS_HA)    // Hier, c'{tait dimanche. ->昨日月曜日だった -> 昨日<は>
  1158.         MyPrintf("は");
  1159. }
  1160.  
  1161. //
  1162. // 数値の表示
  1163. //
  1164. void
  1165. PrintOutNumetric(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1166. {
  1167.     char    *unit = "";
  1168.     if(p->child)
  1169.         PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1170.  
  1171.     if(p->prtControl == PRT_CONTROL_DISABLE)    return;
  1172.  
  1173.     if(p->jpUnit) {
  1174.         unit = GetJpUnit(p->jpUnit);
  1175.     } else if(parent) {
  1176.         if(parent->frPart == FR_PART_NOUN_GENERAL && parent->which) {
  1177.             JP_NOUN    *jpNoun = (JP_NOUN *)parent->which;
  1178.             unit = GetJpUnit(jpNoun->jpUnit);
  1179.         } else if(parent->frPart & FR_PART_NOUN) {    // 中性代名詞とか、目的代名詞とか
  1180.             unit = GetJpUnit(parent->jpUnit);
  1181.             if(unit[0] == '\0')    unit = "(つ/人)";    // il y en a deux. -> ２<つ/人>ある。
  1182.         } else {
  1183.             unit = "(つ/人)";        // これが一番無難？
  1184.         }
  1185.     }
  1186.  
  1187.     if( p->frPart != FR_PART_NUMETRIC_NUMBER
  1188.     ||  parent == NULL
  1189.     // Je n'ai pas <une> robe. 私は一つ<も>洋服を持っていない
  1190.     || ((parent->frPart & FR_PART_VERB) && (parent->jpProp & JP_PROP_NEGATIVE))
  1191.     // 一部の数詞は、動詞に掛けてある eg) 一冊の辞書を持っている -> 辞書を一冊持っている
  1192. //    ||  IsObjectMatch(parent, (FR_PART)(FR_PART_NOUN_ALL | FR_PART_VERB_ALL)) == FALSE
  1193.     || (parent->jpProp & JP_PROP_UNIT)
  1194.     ||  p->value != 1)
  1195.     ;                // 1件でも、あてはまれば、表示
  1196.     else return;    // きっと冠詞の un, une でしょう。
  1197.  
  1198.     JP_KIND    jpKind = JP_KIND_RENTAISHI;
  1199.     int    value = p->value;
  1200.  
  1201.     if((p->prtControl & PRT_CONTROL_MINUS1)
  1202.     && value > 1)
  1203.         value--;
  1204.  
  1205.     if(p->frPart == FR_PART_NUMETRIC_NUMBER) {
  1206.         MyPrintf("%d%s", value, unit);
  1207.         if(value == 1
  1208.         && parent
  1209.         && !(parent->jpEmphasis & JP_EMPHASIS_ONLY)
  1210.         && (parent->jpProp & JP_PROP_NEGATIVE)) {        // Je n'ai pas <une> robe. 私は一つ<も>洋服を持っていない
  1211.             MyPrintf("も");
  1212.         }
  1213.     } else if(p->frPart == FR_PART_NUMETRIC_ORDER) {
  1214.         MyPrintf("%d番目", p->value);
  1215.     } else if(p->frPart == FR_PART_NUMETRIC_FRACTION) {
  1216.         MyPrintf("分の%d", p->value);
  1217.     } else if(p->frPart == FR_PART_NUMETRIC_COMBIEN) {
  1218.         if(unit[0])    MyPrintf("何%s", unit);
  1219.         else        MyPrintf("どのくらい");
  1220.     } else if(p->frPart == FR_PART_NUMETRIC_EXCLAMINATION) {
  1221.         if(unit[0])    MyPrintf("何%s", unit);
  1222.         else         MyPrintf("何て多く");
  1223.     } else if(p->frPart == FR_PART_NUMETRIC_CHOICE) {
  1224.         MyPrintf("%d%sの中で", p->value, unit);
  1225.         jpKind = JP_KIND_NONE;
  1226.     } else {
  1227.         PrintInternalError( "Internall Error <PrintOutNumetric>\n");
  1228.         jpKind = JP_KIND_NONE;
  1229.     }
  1230.  
  1231.     if(parent == NULL
  1232.     || (parent && parent->jpUnit == JP_UNIT_UNIT)) {
  1233.     } else {
  1234.         PrintOutVerbTail3(p, jpKind, jpChange);
  1235.     }
  1236. }
  1237.  
  1238. char
  1239. *GetJpUnit(JP_UNIT jpUnit)
  1240. {
  1241.     switch(jpUnit) {
  1242.     case JP_UNIT_KO:    return "個";
  1243.     case JP_UNIT_DAI:    return "台";
  1244.     case JP_UNIT_HITO:    return "人";
  1245.     case JP_UNIT_HON:    return "本";
  1246.     case JP_UNIT_SATU:    return "冊";
  1247.     case JP_UNIT_TSU:    return "つ";
  1248.     case JP_UNIT_HIKI:    return("匹");
  1249.     case JP_UNIT_TOU:    return("頭");
  1250.     case JP_UNIT_WA:    return("羽");
  1251.     case JP_UNIT_CHAKU:    return "着";
  1252.     }
  1253.     return "";
  1254. }
  1255.  
  1256. //
  1257. // 前置詞の表示
  1258. //
  1259. void
  1260. PrintOutPreposition(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1261. {
  1262.     JP_PREPOSITION    *jpPreposition = (JP_PREPOSITION *)p->which;
  1263.  
  1264.     if(jpPreposition == NULL) {
  1265.         // もう一度、確認 (昔は､verb Tokenがwhich == NULLだったとか...)
  1266.         jpPreposition = MatchParentPreposition(parent, p);
  1267.         if(jpPreposition == NULL) {
  1268.             // それでもだめなら､最後の候補 = 一番つぶしが効く
  1269.             PREPOSITION    *dic = (PREPOSITION *)p->what;
  1270.             jpPreposition = &dic->jpPreposition[dic->proposed - 1];
  1271.         }
  1272.     }
  1273.  
  1274.     if(p->prtControl == PRT_CONTROL_REPLACED) {
  1275.         PrintOutTokens(NULL, p->object1, jpChange);
  1276.     } else if(p->prtControl == PRT_CONTROL_ENABLE)    {
  1277.         PrintOutMacroStr(jpPreposition->japanese, NULL, p, JP_CHANGE_NONE);
  1278.         PrintOutJpChange(jpPreposition->jpKind, jpChange);
  1279.     }
  1280. }
  1281.  
  1282. //
  1283. // 関係代名詞/副詞の表示
  1284. //
  1285. void
  1286. PrintOutRelative(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1287. {
  1288.     jpChange = JP_CHANGE_ADJECTIVE;
  1289.  
  1290.     if(parent
  1291.     && (parent->jpEmphasis & JP_EMPHASIS_SENTENCE)) {
  1292.         // 強調構文 窓を壊した私 -> 窓を壊した<のは>私
  1293.         jpChange = JP_CHANGE_STOP;
  1294.     }
  1295.  
  1296.     if(p->child)
  1297.         PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1298.  
  1299.     if(IsObjectMatch(p, FR_PART_RELATIVE_SUBJECT)
  1300.     && p->object1
  1301.     && (p->object1->frPart & FR_PART_VERB)) {
  1302.         PrintOutVerb(NULL, p->object1, jpChange);
  1303.     } else if(IsObjectMatch(p, FR_PART_RELATIVE_OBJECT)
  1304.     && p->object1) {
  1305.         PrintOutVerb(p->object1->subject, p->object1, jpChange);
  1306.     } else if(p->frPart == FR_PART_RELATIVE_ADVERB
  1307.     && p->object1) {
  1308.         PrintOutVerb(p->object1->subject, p->object1, jpChange);
  1309.     } else if(p->frPart == FR_PART_RELATIVE_SENTENCE
  1310.     && p->object1) {
  1311.         PrintOutVerb(p->object1->subject, p->object1, jpChange);
  1312.     }
  1313.  
  1314.     if(jpChange == JP_CHANGE_STOP)
  1315.         MyPrintf("のは");
  1316. }
  1317.  
  1318. //
  1319. // 連結詞の表示
  1320. //
  1321. void
  1322. PrintOutCombine(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1323. {
  1324.     if(p->prtControl != PRT_CONTROL_ENABLE)
  1325.         return;
  1326.  
  1327.     if(p->child) {
  1328.         if(p->frPart & FR_PART_NOUN)
  1329.             PrintOutTokens(p, p->child, JP_CHANGE_ADJECTIVE);
  1330.         else
  1331.             PrintOutTokens(p, p->child, JP_CHANGE_CONT);
  1332.     }
  1333.  
  1334.     COMBINE    *combine = (COMBINE *)p->what;
  1335.     JP_COMBINE    *jpCombine = (JP_COMBINE *)p->which;
  1336.  
  1337.     if(jpCombine == NULL) {
  1338.         jpCombine = &combine->jpCombine[combine->proposed - 1];
  1339.     }
  1340.  
  1341.     PrintOutMacroStr(jpCombine->japanese, parent, p, jpChange);
  1342.     PrintOutVerbTail3(p, jpCombine->jpKind, jpChange);
  1343. }
  1344.  
  1345. //
  1346. // 接続詞の表示
  1347. //
  1348. void
  1349. PrintOutConjunction(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1350. {
  1351.     if(p->child) {
  1352.         PrintOutTokens(p, p->child,  JP_CHANGE_CONT);
  1353.     }
  1354.  
  1355.     if(p->prtControl != PRT_CONTROL_ENABLE)    return;
  1356.  
  1357.     if(p->frPart == FR_PART_CONJUNCTION_THAN) {
  1358.         if(p->child)    PrintOutTokens(p, p->child, JP_CHANGE_STOP);
  1359.         if(p->object1)    PrintOutTokens(p, p->object1, JP_CHANGE_STOP);
  1360.         PrintOutCompare(parent, parent);
  1361.     }
  1362. }
  1363.  
  1364. //
  1365. // 疑問詞の表示（文章になっていない物のみ）
  1366. // eg) quoi d'autre?
  1367. //
  1368. void
  1369. PrintOutInterrogative(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1370. {
  1371.     if(p->child) {
  1372.         if((p->frPartChoice & FR_PART_ADVERB)
  1373.         || (p->frPartChoice & FR_PART_ADJECTIVE))
  1374.             PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1375.         else
  1376.             PrintOutTokens(p, p->child, JP_CHANGE_ADJECTIVE);
  1377.     }
  1378.     MyPrintf(((QUESTION *)p->what)->japanese);
  1379.     JP_KIND jpKind = ((QUESTION *)p->what)->jpKind;
  1380.     PrintOutVerbTail3(p, jpKind, jpChange);
  1381. }
  1382.  
  1383. BOOL
  1384. IsWordQuestion(TOKEN *p)
  1385. {
  1386.     while(p) {
  1387.         if(IsWordQuestion(p->child))
  1388.             return(TRUE);
  1389.         if(p->frPart & FR_PART_INTERROGATIVE)
  1390.             return(TRUE);
  1391.         p = p->next;
  1392.     }
  1393.     return(FALSE);
  1394. }
  1395.  
  1396. void
  1397. SortToken(TOKEN *start, FR_PATTERN *table)
  1398. {
  1399. retry:
  1400.     TOKEN *p = start;
  1401.     while(p && p->next) {
  1402.         TOKEN *next = p->next;
  1403.         if(GetTokenOrder(p, table) < GetTokenOrder(next, table)) {
  1404.             SwapToken(p, next);
  1405.             goto retry;
  1406.         }
  1407.         p = next;
  1408.     }
  1409. }
  1410.  
  1411. int
  1412. GetTokenOrder(TOKEN *p, FR_PATTERN *table)
  1413. {
  1414.     int    ret = 0;
  1415.  
  1416.     while(table->cmpToken.frPart != FR_PART_NONE) {
  1417.         if(table->cmpToken.frPart == FR_PART_ALL
  1418.         || IsObjectMatch(p, table->cmpToken)) {
  1419.             ret = table->order;
  1420.             if(p->child)    ret += GetTokenOrder(p->child, table);
  1421.             if(p->object1)    ret += GetTokenOrder(p->object1, table);
  1422.             if(p->object2)    ret += GetTokenOrder(p->object2, table);
  1423.             return(ret);
  1424.         }
  1425.         table++;
  1426.     }
  1427.     return(0);
  1428. }
  1429.  
  1430. //
  1431. // FR_PART_SPECIALを（出来る範囲で）表示
  1432. //
  1433. void
  1434. PrintOutSpecial(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1435. {
  1436.     if(p->child) {
  1437.         if((p->frPartChoice & FR_PART_ADVERB)
  1438.         || (p->frPartChoice & FR_PART_ADJECTIVE))
  1439.             PrintOutTokens(p, p->child, JP_CHANGE_ADVERB);
  1440.         else
  1441.             PrintOutTokens(p, p->child, JP_CHANGE_ADJECTIVE);
  1442.     }
  1443.     switch(p->frPart) {
  1444.     case FR_PART_SPECIAL_COMMA:
  1445.         MyPrintf("、");
  1446.         break;
  1447.     }
  1448. }
  1449.  
  1450. //
  1451. // FR_PART_INDEPENDENCEを表示
  1452. //
  1453. void
  1454. PrintOutIndependence(TOKEN *parent, TOKEN *p, JP_CHANGE jpChange)
  1455. {
  1456.     if(p->frPart & FR_PART_COMBINE) {
  1457.         if(p->object1)
  1458.             PrintOutIndependence(parent, p->object1, jpChange);
  1459.         if(p->object2)
  1460.             PrintOutIndependence(parent, p->object2, jpChange);
  1461.     }
  1462.  
  1463.     if(p->child) {
  1464.         PrintOutTokens(NULL, p->child, JP_CHANGE_ADJECTIVE);
  1465.     }
  1466.  
  1467.     if(p->prtControl != PRT_CONTROL_ENABLE)
  1468.         return;
  1469.  
  1470.     switch(p->frPart) {
  1471.     case FR_PART_INDEPENDENCE_INTERJECTION:
  1472.         if(p->what) {
  1473.             INTERJECTION    *interjection = (INTERJECTION *)p->what;
  1474.             MyPrintf(interjection->japanese);
  1475.         }
  1476.         break;
  1477.     case FR_PART_INDEPENDENCE_NOUN:
  1478.         if(p->which == NULL) {    // 日本語訳が確定していない時は、一番つぶしが効くものを
  1479.             NOUN *noun = (NOUN *)p->what;
  1480.             p->which = &noun->jpNoun[noun->proposed-1];
  1481.         }
  1482.         PrintOutMacroStr(((JP_NOUN *)p->which)->japanese, NULL, p, JP_CHANGE_STOP);
  1483.         break;
  1484.     }
  1485. }
  1486.  
  1487. //
  1488. // <Child> fieldを含めて、Tokenを数える
  1489. //
  1490. int
  1491. CountTokensWChild(TOKEN *start)
  1492. {
  1493.     TOKEN *p;
  1494.     int    cnt = 0;
  1495.  
  1496.     for(p = start; p; p = p->next) {
  1497.         if(p->prtControl == PRT_CONTROL_DISABLE
  1498.         || p->prtControl == PRT_CONTROL_DISPLAYED)
  1499.             continue;
  1500.  
  1501.         cnt++;
  1502.         if(p->subject)    cnt += CountTokensWChild(p->subject);
  1503.         if(p->child)    cnt += CountTokensWChild(p->child);
  1504.         if(p->object1)    cnt += CountTokensWChild(p->object1);
  1505.         if(p->object2)    cnt += CountTokensWChild(p->object2);
  1506.     }
  1507.     return(cnt);
  1508. }
  1509.  
  1510.     
  1511. JP_KIND
  1512. GetJpKind(TOKEN *p)
  1513. {
  1514.     if(p->frPart & FR_PART_COMBINE) {
  1515.         // 後に表示される日本語
  1516.         return(GetJpKind(p->object2));
  1517.     }
  1518.     else if(p->frPart & FR_PART_VERB) {
  1519.         const JP_VERB    *jpVerb = (JP_VERB *)p->which;
  1520.         if(jpVerb == NULL) {
  1521.             VERB    *dic = (VERB *)p->what;
  1522.             jpVerb = &dic->jpVerb[dic->proposed - 1];
  1523.         }
  1524.         return(jpVerb->jpKind);
  1525.     }
  1526.     else if(p->frPart & FR_PART_NOUN) {
  1527.         return(JP_KIND_NONE);
  1528.     }
  1529.     else if(IsObjectMatch(p, FR_PART_ADJECTIVE_GENERAL)) {
  1530.         JP_ADJECTIVE    *jpAdjective = (JP_ADJECTIVE *)p->which;
  1531.         if(jpAdjective == NULL) {
  1532.             ADJECTIVE    *dic = (ADJECTIVE *)p->what;
  1533.             jpAdjective = &dic->jpAdjective[dic->proposed - 1];
  1534.         }
  1535.         return(jpAdjective->jpKind);
  1536.     }
  1537.     else if(IsObjectMatch(p, FR_PART_ADVERB_GENERAL)) {
  1538.         JP_ADVERB        *jpAdverb = (JP_ADVERB *)p->which;
  1539.         if(jpAdverb == NULL) {
  1540.             ADVERB    *dic = (ADVERB *)p->what;
  1541.             jpAdverb = &dic->jpAdverb[dic->proposed - 1];
  1542.         }
  1543.         return(jpAdverb->jpKind);
  1544.     }
  1545.     else if(IsObjectMatch(p, FR_PART_PREPOSIT_ALL)) {
  1546.         JP_PREPOSITION        *jpPreposition = (JP_PREPOSITION *)p->which;
  1547.         if(jpPreposition == NULL) {
  1548.             PREPOSITION    *dic = (PREPOSITION *)p->what;
  1549.             jpPreposition = &dic->jpPreposition[dic->proposed - 1];
  1550.         }
  1551.         return(jpPreposition->jpKind);
  1552.     }
  1553.     return(JP_KIND_NONE);
  1554. }
  1555.